//============================================================================================
/**
 * @file	gs_ending_demo.c
 * @brief	エンディングデモ　メイン
 * @author	NozomuSaito
 * @date	2009.03.30
 */
//============================================================================================
#include "common.h"
#include "system\procsys.h"
#include "system\msgdata.h"
#include "system\font_arc.h"
#include "system/fontproc.h"
#include "system\brightness.h"
#include "system\clact_util.h"
#include "system\render_oam.h"
#include "system\snd_tool.h"
#include "system/wipe.h"
///#include "savedata\zukanwork.h"
///#include "poketool\monsno.h"

#include "msgdata\msg.naix"


///#include "demo_ending_common.h"
///#include "demo_ending_list.h"

#include "demo\demo_ending.h"	//for	ENDING_PROC_PARAM
#include "demo\gs_ending_demo.h"
#include "ending_demo.naix"


#include "msgdata\msg_stafflist.h"

#include "gs_ending_demo_def.h"

#define MOV_ACTOR_MAX	(16)
#define DANCE_SC_NUM	(6)

#define	FLDMOV_MAX	(6)		//フィールドアクター同時管理最大数

#define POKE_DANCE_RES_NUM	(1)
#define FLD_MOV_RES_NUM	(FLDMOV_MAX)
#define RES_NUM	(POKE_DANCE_RES_NUM+FLD_MOV_RES_NUM)

#define RESOURCE_TYPE_NUM	(4)

#define DANCE_ACT_MAX	(12*2)

#define ACT_MAX		(DANCE_ACT_MAX+MOV_ACTOR_MAX)
#define PAL_MAX		(7+6)		//ダンス+フィールド
#define DEMO_ACT_MAX	(ACT_MAX)
//アクター準備
#define CHAR_CONT_NUM				(ACT_MAX)
#define CHAR_VRAMTRANS_MAIN_SIZE	(0)
#define CHAR_VRAMTRANS_SUB_SIZE		(0)
#define PLTT_CONT_NUM				(PAL_MAX)

#define HEAPSIZE_ENDING_DEMO	(0x40000)

#define POKE_DANCE_PAL_NUM	(7)
#define FLD_MOV_PAL_NUM	(1)

#define DANCE_POKE_NUM	(12)		//上下画面各6匹
#define DANCE_POKE_BG_PRI	(1)
#define FLD_MOV_BG_PRI		(3)

#define DANCE_POKE_DEF_LEFT_X	(2*8)
#define DANCE_POKE_DEF_RIGHT_X	((32-2)*8)
#define DANCE_POKE_BASE_Y	(8*2)
#define DANCE_POKE_HEIGHT_MARGINE	(10*8)

#define FLD_MOV_X	(128)
#define FLD_MOV_Y	(96)

#define DIFF_MAIN_SUB_LCD (256)

#define ACT_PAL_SIZE	(2*16)		//16色1本分

//ＢＭＰ関連
#define FONT_PAL	(15)
#define WIN_CGX_BASE	(1)
#define MSG_BG	(GF_BGL_FRAME1_S)
#define WIN_PX		(3)
#define WIN_PY		(0)
#define WIN_SX		(24)
#define WIN_SY		(24)

#define STRBUF_SIZE	(256)


typedef enum{
	ACT_ID_POKE_DANCE = 1,
	ACT_ID_FLD_MOV,
	ACT_ID_FLD_MOV2,
	ACT_ID_FLD_MOV3,
	ACT_ID_FLD_MOV4,
	ACT_ID_FLD_MOV5,
	ACT_ID_FLD_MOV6,
}ACT_ID;

typedef enum{
	PD_ANM_NONE = 0,
	PD_ANM_HANA,
	PD_ANM_ZOU,
	PD_ANM_ELE,
	PD_ANM_KUMA,
	PD_ANM_HANE,
	PD_ANM_BALL,
	PD_ANM_SMG,
}POKE_DANCE_ANM_NO;

typedef enum {
	DC_SEQ_NONE,
	DC_SEQ_START,
	DC_SEQ_POKE_CHG,
	DC_SEQ_CHG_WAIT,
}DC_SEQ;

typedef enum{
	SR_SEQ_DISP_WAIT,
	SR_SEQ_SLIDE_IN_START,
	SR_SEQ_SLIDE_IN_WAIT,
	SR_SEQ_SLIDE_OUT_WAIT,
}SR_SEQ;

typedef enum{
	SLIDE_TYPE_IN,
	SLIDE_TYPE_OUT,
}SLIDE_TYPE;

typedef struct POKE_DANCE_tag
{
	CLACT_WORK_PTR		Poke[DANCE_POKE_NUM];
	CLACT_WORK_PTR		Smog[DANCE_POKE_NUM];
	u8 Counter;
	u8 Seq;
	u8 Scene;
	u8 ChgCount;
}POKE_DANCE;

typedef struct SLIDE_WORK_tag
{
	int Counter;
	BOOL Valid;
	SLIDE_TYPE Type;
	TCB_PTR Tcb;
	GF_BGL_INI *Bgl;
}SLIDE_WORK;

typedef struct STAFF_ROLL_tag
{
	MSGDATA_MANAGER*	MsgMan;
	GF_BGL_BMPWIN	Win;
	STRBUF*		StrBuf;
	SLIDE_WORK Slide;
	u8 Counter;
	u8 Seq;
	u8 PageNum;
	u8 StfDatIdx;
}STAFF_ROLL;

typedef struct DISP_SWITCH_tag
{
	u16 Req;
	u16 SwNum;
	TCB_PTR Tcb;

}DISP_SWITCH;

typedef struct ACTOR_tag
{
	u16 Valid;
	u16 Code;
	int StartFrm;
	CLACT_WORK_PTR ActPtr;
}ACTOR;

typedef struct MOV_ACT_tag
{
	ACTOR Actor[MOV_ACTOR_MAX];
	int EntryIdx;
}MOV_ACT;

typedef struct MOV_ACT_CNT_tag
{
	//リソース識別子
	int Code;
	u32 ImageVram;
	u32 PaletteVram;
	const NNSG2dImagePaletteProxy *PalProxy;
	NNSG2dImageProxy *ImageProxy;
	//キャラ
	NNSG2dCharacterData *Char;
	//パレット
	NNSG2dPaletteData  *Pal;
	//セルバンク
	NNSG2dCellDataBank *CellBank;
	//セルアニメバンク
	NNSG2dAnimBankData *AnmBank;
	//キャラデータ
	void *ChrData;
	//パレットデータ
	void *PalData;
	//セルデータ
	void *CellData;
	//アニメデータ
	void *AnmData;
}MOV_RES;

typedef struct MOV_ACT_MNG_tag
{
	//ハンドル
	ARCHANDLE *Handle;
	u16 EntryIdx;
	u16 SceneNo;
	MOV_RES MvRes[FLDMOV_MAX];
	MOV_ACT	MovAct;
	int PlayerSex;
}MOV_ACT_MNG;


typedef struct GS_ENDING_DEMO_WORK_tag{
	PROC*				proc;
	GF_BGL_INI*			bgl;

	u32 TotalFrame;
	int Counter;

	ENDING_PROC_PARAM*   procParam;
	BOOL                 skipFlag;

	CLACT_SET_PTR				ClactSet;
	CLACT_U_EASYRENDER_DATA		RendData;
	CLACT_U_RES_MANAGER_PTR	ResMan[RESOURCE_TYPE_NUM];				// リソースマネージャ

	CLACT_U_RES_OBJ_PTR 	ResObjTbl[RESOURCE_TYPE_NUM];		// リソースオブジェテーブル
	CLACT_U_RES_OBJ_PTR 	FldResObjTbl[FLDMOV_MAX][RESOURCE_TYPE_NUM];		// フィールドアクターリソースオブジェテーブル
	POKE_DANCE			PokeDance;
	STAFF_ROLL			StaffRoll;
	DISP_SWITCH			DispSwitch;
	MOV_ACT_MNG			MovActMng;
	void *Bg1Arc[DANCE_SC_NUM];
	void *Bg2Arc[DANCE_SC_NUM];
	NNSG2dScreenData *Scrn1Data[DANCE_SC_NUM];
	NNSG2dScreenData *Scrn2Data[DANCE_SC_NUM];
}GS_ENDING_DEMO_WORK;


//datファイル用構造体定義
typedef struct
{
	u16 PageNo;
	u8 X;
	u8 Y;
	int MsgID;
}STAFF_DAT;

typedef struct
{
	u16 StartFrm;
	u16 DispWait;
}PAGE_DAT;

typedef int SWITCH_DAT;
typedef int BG_FRM_DAT;

typedef struct SC_ACT_tag
{
	u16 ActCode;
	u8 ResIdx;
	u8 AnmNo;
	s16 X;
	s16 Y;
	int Frm;
}SC_ACT;

typedef struct SCENE_DAT_tag
{
	u8 ResNum;
	u8 ActNum;
	u8 ResNo[FLDMOV_MAX];
	SC_ACT ScAct[MOV_ACTOR_MAX];
}SCENE_DAT;

typedef struct GRA_DAT_TBL_tag
{
	int clr;
	int cgr;
	int cer;
	int anr;
}GRA_DAT_TBL;

#include "staff.dat"
#include "page.dat"
#include "switch.dat"
#include "bgfrm.dat"
#include "scene.dat"

static void VBlankFunc( void* wk_adrs );
static void SetBank(void);
static void SetupBg( GS_ENDING_DEMO_WORK* wk );
static void DelBg( GS_ENDING_DEMO_WORK* wk );
static void LoadBG(GS_ENDING_DEMO_WORK* wk);
static void InitCellActor(GS_ENDING_DEMO_WORK *wk);
static void EndCellActor(GS_ENDING_DEMO_WORK *wk);
static void LoadActRes(GS_ENDING_DEMO_WORK *wk);
static void DelActRes(GS_ENDING_DEMO_WORK *wk);
static void AttouchVramAdr( GS_ENDING_DEMO_WORK *wk );

static void SetAct(GS_ENDING_DEMO_WORK *wk);

static void MakeClActHeader(const int inActID, GS_ENDING_DEMO_WORK *wk,
							const int inPriority,
							const int inVramType,
						 	CLACT_ADD *outAdd, CLACT_HEADER *outClActHeader);
static void MakeClActHeaderForFldMov(const int inCntIdx, GS_ENDING_DEMO_WORK *wk,
							const int inPriority,
							const int inVramType,
						 	CLACT_ADD *outAdd, CLACT_HEADER *outClActHeader);

static void SetVTask(GS_ENDING_DEMO_WORK *wk);
static void DelVTask(GS_ENDING_DEMO_WORK *wk);

static void StaffRollMain(GS_ENDING_DEMO_WORK *wk);
static void PokeDanceMain(GS_ENDING_DEMO_WORK *wk);
static void DispSwitchMain(GS_ENDING_DEMO_WORK *wk);
static void ActMovMain(GS_ENDING_DEMO_WORK *wk);

static void StartActMov(CLACT_WORK_PTR act);

static void ReqDispSwitch(GS_ENDING_DEMO_WORK *wk);
static void TCB_DispSwitch( TCB_PTR tcb, void* work );

static void CreateBmpWin(GS_ENDING_DEMO_WORK *wk);

static void ReqSlide(SLIDE_WORK *work, GF_BGL_INI *bgl, const SLIDE_TYPE inType);
static BOOL CheckSlide(SLIDE_WORK *work);
static void TCB_Slide( TCB_PTR tcb, void* work );
static void SetWinRect(const int inSX, const int inSY, const int inEX, const int inEY);
static void RewritePage(STAFF_ROLL* sr);


static void LoadSceneRes(MOV_ACT_MNG *mng, const u8 inResNo);
static void SetSceneActor( GS_ENDING_DEMO_WORK *wk, const SC_ACT *sc_act );
static void SetupNextScene( GS_ENDING_DEMO_WORK *wk );
static void FreeScene(GS_ENDING_DEMO_WORK *wk);

static const u8 SceneDancePoke[] = {
	PD_ANM_BALL,
	PD_ANM_HANA,
	PD_ANM_ZOU,
	PD_ANM_KUMA,
	PD_ANM_ELE,
	PD_ANM_HANE,
};

//ＢＮＰウィンドウデータ
static const BMPWIN_DAT BmpData = {
		MSG_BG, WIN_PX, WIN_PY, WIN_SX, WIN_SY,
		FONT_PAL, WIN_CGX_BASE
};

//------------------------------------------------------------------
/**
 * エンディングデモPROC初期化
 *
 * @param   proc
 * @param   seq
 *
 * @retval  PROC_RESULT
 */
//------------------------------------------------------------------
PROC_RESULT GS_EndingDemoProc_Init( PROC * proc, int * seq )
{
	GS_ENDING_DEMO_WORK* wk;

	switch( *seq ){
	case 0:
		sys_CreateHeap( HEAPID_BASE_APP, HEAPID_ENDING_DEMO, HEAPSIZE_ENDING_DEMO );
		wk = PROC_AllocWork( proc, sizeof(GS_ENDING_DEMO_WORK), HEAPID_ENDING_DEMO );
		if( wk )
		{
			//メモリをクリアする
			MI_CpuClear8( wk, sizeof(GS_ENDING_DEMO_WORK) );

			sys_VBlankFuncChange( NULL, NULL );
			sys_HBlankIntrStop();

			GF_Disp_GX_VisibleControlInit();
			GF_Disp_GXS_VisibleControlInit();
			GX_SetVisiblePlane( 0 );
			GXS_SetVisiblePlane( 0 );

			SetBank();

			wk->procParam = PROC_GetParentWork( proc );
			wk->skipFlag = FALSE;

			//３Ｄ描画スイッチ(下画面がメイン)
			sys.disp3DSW = DISP_3D_TO_SUB;
			GF_Disp_DispSelect();

			InitCellActor(wk);
			LoadActRes(wk);

			//OBJVRAMプロキシアタッチ
			AttouchVramAdr( wk );

			//サーフェイス設定
			CLACT_U_SetSubSurfaceMatrix( &(wk->RendData), 0, 0 );
			CLACT_U_SetMainSurfaceMatrix( &(wk->RendData), 0, (DIFF_MAIN_SUB_LCD<<FX32_SHIFT) );

			wk->proc = proc;

			(*seq)++;

		}
		break;
	case 1:
		wk = PROC_GetWork( proc );
		{
			SetupBg( wk );
			SetAct( wk );

			wk->StaffRoll.MsgMan = MSGMAN_Create( MSGMAN_TYPE_NORMAL, ARC_MSG, NARC_msg_stafflist_dat, HEAPID_ENDING_DEMO );
			wk->StaffRoll.StrBuf = STRBUF_Create( STRBUF_SIZE, HEAPID_ENDING_DEMO );

			CreateBmpWin(wk);

			//Ｖタスク登録
			SetVTask(wk);

			//はじめのページ書く
			{
				int msg_id;
				//金銀で分岐
				if (PM_VERSION == VERSION_GOLD){
					msg_id = ENDING_STRID_0000;
				}else{
					msg_id = ENDING_STRID_0001;
				}
				MSGMAN_GetString( wk->StaffRoll.MsgMan, msg_id, wk->StaffRoll.StrBuf );
				GF_BGL_BmpWinDataFill( &wk->StaffRoll.Win, 0);
				GF_STR_PrintColor( &wk->StaffRoll.Win, FONT_SYSTEM, wk->StaffRoll.StrBuf, StfDat[0].X, StfDat[0].Y,
						MSG_NO_PUT, GF_PRINTCOLOR_MAKE(1,2,0), NULL );
				GF_BGL_BmpWinOn(&wk->StaffRoll.Win);

				wk->StaffRoll.StfDatIdx = 1;		//次のスタッフデータインデックスをセット
			}
			Snd_DataSetByScene( SND_SCENE_ENDING, SEQ_GS_ENDING, 1 );	//エンディング曲再生

			sys_VBlankFuncChange( VBlankFunc, wk );
		}
		(*seq)++;
		break;

	case 2:
		wk = PROC_GetWork( proc );
		{
			WIPE_SYS_Start( WIPE_PATTERN_WMS, WIPE_TYPE_FADEIN, WIPE_TYPE_FADEIN,
					 WIPE_FADE_BLACK, BACK_IN_SYNC, 1, HEAPID_ENDING_DEMO );
			return PROC_RES_FINISH;
		}
		break;
	}
	return PROC_RES_CONTINUE;
}


//------------------------------------------------------------------
/**
 * エンディングデモPROC終了
 *
 * @param   proc
 * @param   seq
 *
 * @retval  PROC_RESULT
 */
//------------------------------------------------------------------
PROC_RESULT GS_EndingDemoProc_End( PROC * proc, int * seq )
{
	GS_ENDING_DEMO_WORK* wk = PROC_GetWork( proc );

	switch( *seq ){
	case 0:
		sys_VBlankFuncChange( NULL, NULL );
		(*seq)++;
		break;

	case 1:
		{
			STAFF_ROLL* sr = &wk->StaffRoll;
			//BMP
			GF_BGL_BmpWinDel( &sr->Win );
			MSGMAN_Delete( sr->MsgMan );
			STRBUF_Delete( sr->StrBuf );
		}

		DelBg( wk );

		//スクリーンデータ削除
		{
			u8 i;
			for (i=0;i<DANCE_SC_NUM;i++){
				sys_FreeMemoryEz(wk->Bg1Arc[i]);
				sys_FreeMemoryEz(wk->Bg2Arc[i]);
			}
		}

		//Ｖタスク削除
		DelVTask(wk);

		(*seq)++;
		break;

	case 2:
		//ハンドルクローズ
		ArchiveDataHandleClose( wk->MovActMng.Handle );
		//セル・アニメデータ解放
		DelActRes( wk );
		EndCellActor( wk );
		(*seq)++;
		break;

	case 3:
		PROC_FreeWork( proc );
		sys_DeleteHeap( HEAPID_ENDING_DEMO );
		return PROC_RES_FINISH;
	}

	return PROC_RES_CONTINUE;
}


//------------------------------------------------------------------
/**
 * エンディングデモPROCメイン
 *
 * @param   proc
 * @param   seq
 *
 * @retval  PROC_RESULT
 */
//------------------------------------------------------------------
PROC_RESULT GS_EndingDemoProc_Main( PROC * proc, int * seq )
{
	GS_ENDING_DEMO_WORK* wk = PROC_GetWork( proc );

	GF_ASSERT(wk->TotalFrame < 0xffffffff);

	switch(*seq){
	case 0:
		//ブラックイン待ち
		if( WIPE_SYS_EndCheck() ){
			OS_Printf("残りヒープサイズ＝%d\n",sys_GetHeapFreeSize( HEAPID_ENDING_DEMO));
			(*seq)++;
		}
		break;
	case 1:
		//スキップチェック
		if (wk->procParam->clearFlag){
			//スタート押下でスキップ
			if ( (sys.trg & PAD_BUTTON_START)||(sys.tp_trg) ){
				wk->skipFlag = TRUE;
				//ブラックアウト
				WIPE_SYS_Start( WIPE_PATTERN_WMS, WIPE_TYPE_FADEOUT, WIPE_TYPE_FADEOUT,
						 WIPE_FADE_BLACK, DEMO_END_OUT_SYNC, 1, HEAPID_ENDING_DEMO );
				//BGMフェードアウト
				Snd_BgmFadeOut( 0, DEMO_END_OUT_SYNC-4 );		//指定シンク数はブラックアウトのシンクよりも小さければ、あとは適当。
				(*seq)++;
				break;
			}
		}

		OS_Printf("TOTAL_FRAME = %d\n",wk->TotalFrame);
		//トータルフレームのインクリメント
		wk->TotalFrame++;
		//スタッフリストメイン
		StaffRollMain(wk);
		//ポケダンスメイン
		PokeDanceMain(wk);
		//上下切り替えメイン
		DispSwitchMain(wk);
		//ＯＢＪアニメメイン
		ActMovMain(wk);

		//最終カウンタ越えたか？
		if (wk->TotalFrame >= CONT_DEMO_END_FADE){
			//ブラックアウト
			WIPE_SYS_Start( WIPE_PATTERN_WMS, WIPE_TYPE_FADEOUT, WIPE_TYPE_FADEOUT,
					 WIPE_FADE_BLACK, DEMO_END_OUT_SYNC, 1, HEAPID_ENDING_DEMO );
			(*seq)++;
		}
		break;
	case 2:
		//ブラックアウト待ち
		if (WIPE_SYS_EndCheck()){
			if (wk->skipFlag){
				FreeScene(wk);
			}

			//「ＥＮＤ」用意
			{	//ENDキャラ・スクリーンロード
				//BGキャラ転送
				ArcUtil_BgCharSet(ARC_ENDING_DEMO, NARC_ending_demo_ending_bg_end_lz_ccgr, wk->bgl,
			    	GF_BGL_FRAME1_M, 0, 0, TRUE, HEAPID_ENDING_DEMO);
				//スクリーン転送
				ArcUtil_ScrnSet(ARC_ENDING_DEMO, NARC_ending_demo_ending_bg_end_lz_cscr, wk->bgl,
			  		GF_BGL_FRAME1_M, 0, 32*24*2, TRUE, HEAPID_ENDING_DEMO);
				GF_BGL_LoadScreenReq(wk->bgl, GF_BGL_FRAME1_M);
			}
			GF_Disp_GX_VisibleControl( GX_PLANEMASK_BG0, VISIBLE_OFF );
			GF_Disp_GX_VisibleControl( GX_PLANEMASK_BG2, VISIBLE_OFF );
			GF_Disp_GX_VisibleControl( GX_PLANEMASK_BG3, VISIBLE_OFF );
			GF_Disp_GX_VisibleControl( GX_PLANEMASK_OBJ, VISIBLE_OFF );
			GF_Disp_GX_VisibleControl( GX_PLANEMASK_BG1, VISIBLE_ON );

			//描画スイッチ(上画面がメイン)	「ＥＮＤ」表示は上画面
			sys.disp3DSW = DISP_3D_TO_MAIN;
			GF_Disp_DispSelect();
			//ブラックイン
			WIPE_SYS_Start( WIPE_PATTERN_M, WIPE_TYPE_FADEIN, WIPE_TYPE_FADEIN,
					 WIPE_FADE_BLACK, DEMO_END_IN_SYNC, 1, HEAPID_ENDING_DEMO );

			(*seq)++;
		}
		break;
	case 3:
		//ブラックイン待ち
		if (WIPE_SYS_EndCheck()){
			wk->Counter = 0;
			(*seq)++;
		}
		break;
	case 4:
		if ( (sys.trg & (PAD_BUTTON_A|PAD_BUTTON_START))||(sys.tp_trg) ){
			//ブラックアウト開始
			WIPE_SYS_Start( WIPE_PATTERN_M, WIPE_TYPE_FADEOUT, WIPE_TYPE_FADEOUT,
					 WIPE_FADE_BLACK, LAST_DEMO_END_OUT_SYNC, 1, HEAPID_ENDING_DEMO );
			(*seq) = 6;
		}else{
			wk->Counter++;
			if (wk->Counter >= CONT_START_END_BGM){	//ＢＧＭその2スタート
				Snd_BgmPlay( SEQ_GS_ENDING2 );//エンディング曲再生
				(*seq)++;
			}
		}
		break;
	case 5:	//ボタン押下までループ
		if ( (sys.trg & (PAD_BUTTON_A|PAD_BUTTON_START))||(sys.tp_trg) ){
			//ブラックアウト開始
			WIPE_SYS_Start( WIPE_PATTERN_M, WIPE_TYPE_FADEOUT, WIPE_TYPE_FADEOUT,
					 WIPE_FADE_BLACK, LAST_DEMO_END_OUT_SYNC, 1, HEAPID_ENDING_DEMO );
			(*seq)++;
		}
		break;
	case 6:
		if (WIPE_SYS_EndCheck()){
			//終了
			return PROC_RES_FINISH;
		}
		break;
	}

	CLACT_Draw( wk->ClactSet );

	return PROC_RES_CONTINUE;

}

//------------------------------------------------------------------
/**
 * VBlank
 *
 * @param   wk_adrs
 *
 * @retval  none
 *
 */
//------------------------------------------------------------------
static void VBlankFunc( void* wk_adrs )
{
	GS_ENDING_DEMO_WORK* wk = wk_adrs;
	GF_BGL_VBlankFunc(wk->bgl);

	// レンダラ共有OAMマネージャVram転送
	REND_OAMTrans();
}

//------------------------------------------------------------------
/**
 * バンクセット
 *
 *
 *	@retval  none
 */
//------------------------------------------------------------------
static void SetBank(void)
{
	GF_BGL_DISPVRAM SetBankData = {
		GX_VRAM_BG_128_B,				// メイン2DエンジンのBG
		GX_VRAM_BGEXTPLTT_NONE,			// メイン2DエンジンのBG拡張パレット
		GX_VRAM_SUB_BG_128_C,			// サブ2DエンジンのBG
		GX_VRAM_SUB_BGEXTPLTT_NONE,		// サブ2DエンジンのBG拡張パレット
		GX_VRAM_OBJ_128_A,				// メイン2DエンジンのOBJ
		GX_VRAM_OBJEXTPLTT_NONE,		// メイン2DエンジンのOBJ拡張パレット
		GX_VRAM_SUB_OBJ_16_I,			// サブ2DエンジンのOBJ
		GX_VRAM_SUB_OBJEXTPLTT_NONE,	// サブ2DエンジンのOBJ拡張パレット
		GX_VRAM_TEX_NONE,				// テクスチャイメージスロット
		GX_VRAM_TEXPLTT_NONE			// テクスチャパレットスロット
	};
	GF_Disp_SetBank( &SetBankData );
}

//------------------------------------------------------------------
/**
 * 	ＢＧセットアップ
 *
 * @param   wk		ワークポインタ
 *
 * @retval  none
 */
//------------------------------------------------------------------
static void SetupBg( GS_ENDING_DEMO_WORK* wk )
{
	wk->bgl = GF_BGL_BglIniAlloc( HEAPID_ENDING_DEMO );

	G2_BlendNone();
	G2S_BlendNone();

	{	// BGシステム設定
		GF_BGL_SYS_HEADER BGsys_data = {
			GX_DISPMODE_GRAPHICS,GX_BGMODE_0,GX_BGMODE_0,GX_BG0_AS_2D
		};
		GF_BGL_InitBG( &BGsys_data );
	}

	//--メイン--
	{	//ＢＧ設定(メイン2)
		GF_BGL_BGCNT_HEADER MBG2_Data = {
			0, 0, 0x800, 0,
			GF_BGL_SCRSIZ_256x256, GX_BG_COLORMODE_16,
			GX_BG_SCRBASE_0xe800, GX_BG_CHARBASE_0x00000,
			GX_BG_EXTPLTT_01, 2, 0, 0, FALSE			//プライオリティ2
		};
		GF_BGL_BGControlSet( wk->bgl, GF_BGL_FRAME2_M, &MBG2_Data, GF_BGL_MODE_TEXT );
	}

	{	// ベース背景 ＢＧ設定(メイン3)
		GF_BGL_BGCNT_HEADER MBG3_Data = {
			0, 0, 0x800, 0,
			GF_BGL_SCRSIZ_256x256, GX_BG_COLORMODE_16,
			GX_BG_SCRBASE_0xe000, GX_BG_CHARBASE_0x00000,
			GX_BG_EXTPLTT_01, 3, 0, 0, FALSE			//プライオリティ3
		};
		GF_BGL_BGControlSet( wk->bgl, GF_BGL_FRAME3_M, &MBG3_Data, GF_BGL_MODE_TEXT );
	}

	{	//「ＥＮＤ」表示面
		GF_BGL_BGCNT_HEADER MBG1_Data = {
			0, 0, 0x800, 0,
			GF_BGL_SCRSIZ_256x256, GX_BG_COLORMODE_16,
			GX_BG_SCRBASE_0xd800, GX_BG_CHARBASE_0x00000,
			GX_BG_EXTPLTT_01, 1, 0, 0, FALSE			//プライオリティ1
		};
		GF_BGL_BGControlSet( wk->bgl, GF_BGL_FRAME1_M, &MBG1_Data, GF_BGL_MODE_TEXT );
	}

	//--サブ--
	{	//ＢＧ設定(サブ1)	BMP面
		GF_BGL_BGCNT_HEADER SBG1_Data = {
			0, 0, 0x800, 0,
			GF_BGL_SCRSIZ_256x256, GX_BG_COLORMODE_16,
			GX_BG_SCRBASE_0xe800, GX_BG_CHARBASE_0x08000,
			GX_BG_EXTPLTT_01, 2, 0, 0, FALSE			//プライオリティ2
		};
		GF_BGL_BGControlSet( wk->bgl, GF_BGL_FRAME1_S, &SBG1_Data, GF_BGL_MODE_TEXT );
	}
	{	//ＢＧ設定(サブ2)
		GF_BGL_BGCNT_HEADER SBG2_Data = {
			0, 0, 0x800, 0,
			GF_BGL_SCRSIZ_256x256, GX_BG_COLORMODE_16,
			GX_BG_SCRBASE_0xe000, GX_BG_CHARBASE_0x00000,
			GX_BG_EXTPLTT_01, 1, 0, 0, FALSE			//プライオリティ1
		};
		GF_BGL_BGControlSet( wk->bgl, GF_BGL_FRAME2_S, &SBG2_Data, GF_BGL_MODE_TEXT );
	}

	{	// ベース背景 ＢＧ設定(サブ3)
		GF_BGL_BGCNT_HEADER SBG3_Data = {
			0, 0, 0x800, 0,
			GF_BGL_SCRSIZ_256x256, GX_BG_COLORMODE_16,
			GX_BG_SCRBASE_0xd800, GX_BG_CHARBASE_0x00000,
			GX_BG_EXTPLTT_01, 3, 0, 0, FALSE			//プライオリティ3
		};
		GF_BGL_BGControlSet( wk->bgl, GF_BGL_FRAME3_S, &SBG3_Data, GF_BGL_MODE_TEXT );
	}

	LoadBG(wk);
}

//------------------------------------------------------------------
/**
 * 	ＢＧ解放
 *
 * @param   wk		ワークポインタ
 *
 * @retval  none
 */
//------------------------------------------------------------------
static void DelBg( GS_ENDING_DEMO_WORK* wk )
{
	//bgl解放
	GF_BGL_BGControlExit( wk->bgl, GF_BGL_FRAME1_M );
	GF_BGL_BGControlExit( wk->bgl, GF_BGL_FRAME2_M );
	GF_BGL_BGControlExit( wk->bgl, GF_BGL_FRAME3_M );

	GF_BGL_BGControlExit( wk->bgl, GF_BGL_FRAME1_S );
	GF_BGL_BGControlExit( wk->bgl, GF_BGL_FRAME2_S );
	GF_BGL_BGControlExit( wk->bgl, GF_BGL_FRAME3_S );

	sys_FreeMemoryEz( wk->bgl );
}

//------------------------------------------------------------------
/**
 * BGロード
 *
 * @param   wk			ワークポインタ
 *
 * @retval  none
 */
//------------------------------------------------------------------
static void LoadBG(GS_ENDING_DEMO_WORK* wk)
{
	GF_BGL_INI*			bgl;
	u8 i;

	const int bg_scr_tbl1[DANCE_SC_NUM] = {
		NARC_ending_demo_ending_bg_ball01_lz_cscr,
		NARC_ending_demo_ending_bg_glass01_lz_cscr,
		NARC_ending_demo_ending_bg_town01_lz_cscr,
		NARC_ending_demo_ending_bg_rock01_lz_cscr,
		NARC_ending_demo_ending_bg_rocket01_lz_cscr,
		NARC_ending_demo_ending_bg_sky01_lz_cscr,
	};
	const int bg_scr_tbl2[DANCE_SC_NUM] = {
		NARC_ending_demo_ending_bg_ball02_lz_cscr,
		NARC_ending_demo_ending_bg_glass02_lz_cscr,
		NARC_ending_demo_ending_bg_town02_lz_cscr,
		NARC_ending_demo_ending_bg_rock02_lz_cscr,
		NARC_ending_demo_ending_bg_rocket02_lz_cscr,
		NARC_ending_demo_ending_bg_sky02_lz_cscr,
	};

	bgl = wk->bgl;

	//両面にキャラロード
	ArcUtil_BgCharSet(ARC_ENDING_DEMO, NARC_ending_demo_ending_bg_lz_ccgr,
						bgl, GF_BGL_FRAME3_M, 0, 0, TRUE, HEAPID_ENDING_DEMO);
	ArcUtil_BgCharSet(ARC_ENDING_DEMO, NARC_ending_demo_ending_bg_lz_ccgr,
						bgl, GF_BGL_FRAME3_S, 0, 0, TRUE, HEAPID_ENDING_DEMO);
	//両面にパレットロード
	ArcUtil_PalSet( ARC_ENDING_DEMO, NARC_ending_demo_gs_ending_bg_nclr,
						PALTYPE_SUB_BG, 0, 2*16*7, HEAPID_ENDING_DEMO );		//サブ　0番に16色7本ロード
	ArcUtil_PalSet( ARC_ENDING_DEMO, NARC_ending_demo_gs_ending_bg_nclr,
						PALTYPE_MAIN_BG, 0, 2*16*7, HEAPID_ENDING_DEMO );	//メイン	//0番に16色7本ロード
	//2枚1組のＢＧ6組をメモリにセット
	for (i=0;i<DANCE_SC_NUM;i++){
		wk->Bg1Arc[i] = ArcUtil_ScrnDataGet(ARC_ENDING_DEMO, bg_scr_tbl1[i], TRUE, &wk->Scrn1Data[i], HEAPID_ENDING_DEMO);
		wk->Bg2Arc[i] = ArcUtil_ScrnDataGet(ARC_ENDING_DEMO, bg_scr_tbl2[i], TRUE, &wk->Scrn2Data[i], HEAPID_ENDING_DEMO);
	}

	//一番初めに使用する1組を両面に転送
	GF_BGL_ScreenBufSet( bgl, GF_BGL_FRAME2_M,
					wk->Scrn1Data[0]->rawData, wk->Scrn1Data[0]->szByte );
	GF_BGL_ScreenBufSet( bgl, GF_BGL_FRAME3_M,
					wk->Scrn2Data[0]->rawData, wk->Scrn2Data[0]->szByte );
	GF_BGL_ScreenBufSet( bgl, GF_BGL_FRAME2_S,
					wk->Scrn1Data[0]->rawData, wk->Scrn1Data[0]->szByte );
	GF_BGL_ScreenBufSet( bgl, GF_BGL_FRAME3_S,
					wk->Scrn2Data[0]->rawData, wk->Scrn2Data[0]->szByte );

	GF_BGL_LoadScreenV_Req(bgl, GF_BGL_FRAME2_M);
	GF_BGL_LoadScreenV_Req(bgl, GF_BGL_FRAME3_M);
	GF_BGL_LoadScreenV_Req(bgl, GF_BGL_FRAME2_S);
	GF_BGL_LoadScreenV_Req(bgl, GF_BGL_FRAME3_S);

	//「END」面非表示
	GF_Disp_GX_VisibleControl( GX_PLANEMASK_BG1, VISIBLE_OFF );

}

//------------------------------------------------------------------
/**
 * セルアクター初期
 *
 * @param   wk			ワークポインタ
 *
 * @retval  none
 */
//------------------------------------------------------------------
static void InitCellActor(GS_ENDING_DEMO_WORK *wk)
{
	const int heapid = HEAPID_ENDING_DEMO;

	//マッピングモード設定
	GX_SetOBJVRamModeChar(GX_OBJVRAMMODE_CHAR_1D_128K);
	GXS_SetOBJVRamModeChar(GX_OBJVRAMMODE_CHAR_1D_128K);
	//キャラクター・パレットマネージャーの初期化
	{
		// キャラクタマネージャー初期化
		CHAR_MANAGER_MAKE cm = {
			CHAR_CONT_NUM,
			CHAR_VRAMTRANS_MAIN_SIZE,
			CHAR_VRAMTRANS_SUB_SIZE,
			heapid
		};
		InitCharManager(&cm);
		// パレットマネージャー初期化
		InitPlttManager(PLTT_CONT_NUM, heapid);

		// 読み込み開始位置を初期化
		CharLoadStartAll();
		PlttLoadStartAll();
	}

	// OAMマネージャーの初期化
	NNS_G2dInitOamManagerModule();

	// 共有OAMマネージャ作成
	// レンダラ用OAMマネージャ作成
	REND_OAMInit(
			0, 128,		// メイン画面OAM管理領域
			0, 32,		// メイン画面アフィン管理領域
			0, 128,		// サブ画面OAM管理領域
			0, 32,		// サブ画面アフィン管理領域
			heapid);

	// セルアクター初期化
	wk->ClactSet = CLACT_U_SetEasyInit( DEMO_ACT_MAX, &wk->RendData, heapid );

	//リソースマネージャー初期化
	{
		u8 i;
		u8 tbl[RESOURCE_TYPE_NUM] = {RES_NUM,RES_NUM,RES_NUM,RES_NUM};
		for(i=0;i<RESOURCE_TYPE_NUM;i++){		//リソースマネージャー作成
			wk->ResMan[i] = CLACT_U_ResManagerInit(tbl[i], i, heapid);
		}
	}
}

//------------------------------------------------------------------
/**
 * セルアクター終了
 *
 * @param   wk			ワークポインタ
 *
 * @retval  none
 */
//------------------------------------------------------------------
static void EndCellActor(GS_ENDING_DEMO_WORK *wk)
{
	u8 i;
	//リソースマネージャ解放
	for(i=0;i<RESOURCE_TYPE_NUM;i++){
		CLACT_U_ResManagerDelete(wk->ResMan[i]);
	}

	// セルアクターセット破棄
	CLACT_DestSet(wk->ClactSet);

	//OAMレンダラー破棄
	REND_OAM_Delete();

	DeleteCharManager();
	DeletePlttManager();

}

//------------------------------------------------------------------
/**
 * ＯＢＪリソースロード
 *
 * @param   wk			ワークポインタ
 *
 * @retval  none
 */
//------------------------------------------------------------------
static void LoadActRes(GS_ENDING_DEMO_WORK *wk)
{
	u8 i;
	MOV_ACT_MNG *mng;
	const int heapid = HEAPID_ENDING_DEMO;
	//==ポケダンス系
	//--chara読み込み
	wk->ResObjTbl[CLACT_U_CHAR_RES] = CLACT_U_ResManagerResAddArcChar(
			 							wk->ResMan[CLACT_U_CHAR_RES],
										ARC_ENDING_DEMO, NARC_ending_demo_gs_ending_obj_lz_ccgr,
										TRUE, ACT_ID_POKE_DANCE, NNS_G2D_VRAM_TYPE_MAX, heapid);
	//--pal読み込み
	wk->ResObjTbl[CLACT_U_PLTT_RES] = CLACT_U_ResManagerResAddArcPltt(
										wk->ResMan[CLACT_U_PLTT_RES],
										ARC_ENDING_DEMO, NARC_ending_demo_gs_ending_obj_nclr,
										FALSE, ACT_ID_POKE_DANCE, NNS_G2D_VRAM_TYPE_MAX, POKE_DANCE_PAL_NUM, heapid);
	//--cell読み込み
	wk->ResObjTbl[CLACT_U_CELL_RES] = CLACT_U_ResManagerResAddArcKindCell(
										wk->ResMan[CLACT_U_CELL_RES],
										ARC_ENDING_DEMO, NARC_ending_demo_gs_ending_obj_lz_ccer,
										TRUE, ACT_ID_POKE_DANCE, CLACT_U_CELL_RES, heapid);
	//--同じ関数でanim読み込み
	wk->ResObjTbl[CLACT_U_CELLANM_RES] = CLACT_U_ResManagerResAddArcKindCell(
										wk->ResMan[CLACT_U_CELLANM_RES],
										ARC_ENDING_DEMO, NARC_ending_demo_gs_ending_obj_lz_canr,
										TRUE, ACT_ID_POKE_DANCE, CLACT_U_CELLANM_RES, heapid);

	//アーカイブハンドル取得
	wk->MovActMng.Handle = ArchiveDataHandleOpen( ARC_ENDING_DEMO, heapid );

	mng = &wk->MovActMng;
	mng->PlayerSex = wk->procParam->playerSex;		//主人公性別セット
	OS_Printf("Player is %d\n", mng->PlayerSex);

	//==フィールドアクタアニメ系
	for (i=0;i<FLDMOV_MAX;i++){
		//--chara読み込み
		wk->FldResObjTbl[i][CLACT_U_CHAR_RES] = CLACT_U_ResManagerResAddArcChar_ArcHandle(
											wk->ResMan[CLACT_U_CHAR_RES],
											mng->Handle, NARC_ending_demo_gs_obj_dmy_lz_ccgr,
											TRUE, ACT_ID_FLD_MOV+i, NNS_G2D_VRAM_TYPE_2DMAIN, heapid);
		//--pal読み込み
		wk->FldResObjTbl[i][CLACT_U_PLTT_RES] = CLACT_U_ResManagerResAddArcPltt_ArcHandle(
											wk->ResMan[CLACT_U_PLTT_RES],
											mng->Handle, NARC_ending_demo_gs_obj_dmy_nclr,
											FALSE, ACT_ID_FLD_MOV+i, NNS_G2D_VRAM_TYPE_2DMAIN, FLD_MOV_PAL_NUM, heapid);
	}

	// リソースマネージャーから転送
	// Chara転送
	CLACT_U_CharManagerSet( wk->ResObjTbl[CLACT_U_CHAR_RES] );
	// パレット転送
	CLACT_U_PlttManagerSet( wk->ResObjTbl[CLACT_U_PLTT_RES] );

	for (i=0;i<FLDMOV_MAX;i++){
		// Chara転送
		CLACT_U_CharManagerSet( wk->FldResObjTbl[i][CLACT_U_CHAR_RES] );
		// パレット転送
		CLACT_U_PlttManagerSet( wk->FldResObjTbl[i][CLACT_U_PLTT_RES] );
	}

	GF_Disp_GX_VisibleControl( GX_PLANEMASK_OBJ, VISIBLE_ON );		// MAIN DISP OBJ ON
	GF_Disp_GXS_VisibleControl( GX_PLANEMASK_OBJ, VISIBLE_ON );		// SUB DISP OBJ ON
}

//------------------------------------------------------------------
/**
 * ＯＢＪリソース解放
 *
 * @param   wk			ワークポインタ
 *
 * @retval  none
 */
//------------------------------------------------------------------
static void DelActRes(GS_ENDING_DEMO_WORK *wk)
{
	u8 i;
	// キャラ転送マネージャー破棄
	CLACT_U_CharManagerDelete(wk->ResObjTbl[CLACT_U_CHAR_RES]);
	// パレット転送マネージャー破棄
	CLACT_U_PlttManagerDelete(wk->ResObjTbl[CLACT_U_PLTT_RES]);
	for (i=0;i<FLDMOV_MAX;i++){
		// キャラ転送マネージャー破棄
		CLACT_U_CharManagerDelete(wk->FldResObjTbl[i][CLACT_U_CHAR_RES]);
		// パレット転送マネージャー破棄
		CLACT_U_PlttManagerDelete(wk->FldResObjTbl[i][CLACT_U_PLTT_RES]);
	}
}

//------------------------------------------------------------------
/**
 * アクターセット
 *
 * @param   wk			ワークポインタ
 *
 * @retval  none
 */
//------------------------------------------------------------------
static void SetAct(GS_ENDING_DEMO_WORK *wk)
{
	u8 i;
	POKE_DANCE *dance;
	CLACT_HEADER	cl_act_header;
	CLACT_ADD add;

	dance = &wk->PokeDance;

	//ヘッダー作成
	MakeClActHeader(ACT_ID_POKE_DANCE, wk, DANCE_POKE_BG_PRI,
					NNS_G2D_VRAM_TYPE_MAX,
					&add, &cl_act_header);
	//サブ画面
	for (i=0;i<DANCE_POKE_NUM/2;i++){
		u8 y;
		if (i<3){
			y = i;
			add.mat.x = FX32_ONE * DANCE_POKE_DEF_LEFT_X;
		}else {
			y = i-3;
			add.mat.x = FX32_ONE * DANCE_POKE_DEF_RIGHT_X;
		}
		add.mat.y = FX32_ONE * (DANCE_POKE_BASE_Y+(DANCE_POKE_HEIGHT_MARGINE*y));
		add.pri = 1;
		dance->Poke[i] = CLACT_Add(&add);
		GF_ASSERT(dance->Poke[i] != NULL );
		CLACT_SetAnmFlag(dance->Poke[i],1);	//アニメする
		CLACT_SetDrawFlag(dance->Poke[i], 1);	//表示
		CLACT_AnmChg( dance->Poke[i], PD_ANM_BALL );

		add.pri = 0;
		dance->Smog[i] = CLACT_Add(&add);
		GF_ASSERT(dance->Smog[i] != NULL );
		CLACT_SetAnmFlag(dance->Smog[i],1);	//アニメする
		CLACT_SetDrawFlag(dance->Smog[i], 0);	//非表示
		CLACT_AnmChg( dance->Smog[i], PD_ANM_SMG );
	}

	//メイン画面
	for (i=0;i<DANCE_POKE_NUM/2;i++){
		u8 y;
		u8 idx;
		if (i<3){
			y = i;
			add.mat.x = FX32_ONE * DANCE_POKE_DEF_LEFT_X;
		}else{
			y = i-3;
			add.mat.x = FX32_ONE * DANCE_POKE_DEF_RIGHT_X;
		}
		idx = i+(DANCE_POKE_NUM/2);
		add.mat.y = FX32_ONE * (DIFF_MAIN_SUB_LCD+DANCE_POKE_BASE_Y+(DANCE_POKE_HEIGHT_MARGINE*y));
		add.pri = 1;
		dance->Poke[idx] = CLACT_Add(&add);
		CLACT_SetAnmFlag(dance->Poke[idx],1);	//アニメする
		CLACT_SetDrawFlag(dance->Poke[idx], 1);	//表示
		CLACT_AnmChg( dance->Poke[idx], PD_ANM_BALL );

		add.pri = 0;
		dance->Smog[idx] = CLACT_Add(&add);
		CLACT_SetAnmFlag(dance->Smog[idx],1);	//アニメする
		CLACT_SetDrawFlag(dance->Smog[idx], 0);	//非表示
		CLACT_AnmChg( dance->Smog[idx], PD_ANM_SMG );
	}

	SetupNextScene( wk );

	GF_Disp_GX_VisibleControl( GX_PLANEMASK_OBJ, VISIBLE_ON );
	GF_Disp_GXS_VisibleControl( GX_PLANEMASK_OBJ, VISIBLE_ON );
}

//------------------------------------------------------------------
/**
 * アクターヘッダー作成
 *
 * @param	inActID		アクターＩＤ
 * @param   wk			ワークポインタ
 * @param	inPriority	ＢＧプライオリティ
 * @param	inVramType	ＶＲＡＭ展開タイプ
 * @param	outAdd		アクター追加構造体ポインタ
 * @param	outClActHeader	アクターヘッダーポインタ
 *
 * @retval  none
 */
//------------------------------------------------------------------
static void MakeClActHeader(const int inActID, GS_ENDING_DEMO_WORK *wk,
							const int inPriority,
							const int inVramType,
						 	CLACT_ADD *outAdd, CLACT_HEADER *outClActHeader)
{
	// セルアクターヘッダ作成
	CLACT_U_MakeHeader(	outClActHeader,
						inActID, inActID, inActID, inActID,
						CLACT_U_HEADER_DATA_NONE, CLACT_U_HEADER_DATA_NONE,
						0, inPriority,
						wk->ResMan[CLACT_U_CHAR_RES],
						wk->ResMan[CLACT_U_PLTT_RES],
						wk->ResMan[CLACT_U_CELL_RES],
						wk->ResMan[CLACT_U_CELLANM_RES],
						NULL,NULL);

	{
		outAdd->ClActSet	= wk->ClactSet;
		outAdd->ClActHeader	= outClActHeader;

		outAdd->mat.x		= 0;
		outAdd->mat.y		= 0;
		outAdd->mat.z		= 0;
		outAdd->sca.x		= FX32_ONE;
		outAdd->sca.y		= FX32_ONE;
		outAdd->sca.z		= FX32_ONE;
		outAdd->rot			= 0;
		outAdd->pri			= 0;
		outAdd->DrawArea	= inVramType;
		outAdd->heap		= HEAPID_ENDING_DEMO;
	}
}

//------------------------------------------------------------------
/**
 * アクターヘッダー作成
 *
 * @param	inCntIdx		管理インデックス
 * @param   wk			ワークポインタ
 * @param	inPriority	ＢＧプライオリティ
 * @param	inVramType	ＶＲＡＭ展開タイプ
 * @param	outAdd		アクター追加構造体ポインタ
 * @param	outClActHeader	アクターヘッダーポインタ
 *
 * @retval  none
 */
//------------------------------------------------------------------
static void MakeClActHeaderForFldMov(const int inCntIdx, GS_ENDING_DEMO_WORK *wk,
							const int inPriority,
							const int inVramType,
						 	CLACT_ADD *outAdd, CLACT_HEADER *outClActHeader)
{
	MOV_ACT_MNG *mng;
	MOV_RES *mv_res;
	mng = &wk->MovActMng;
	mv_res = &mng->MvRes[inCntIdx];

	outClActHeader->pCharData = NULL;	// Vram転送以外ではいらない
	// パレットプロクシを取得
	outClActHeader->pPaletteProxy = mv_res->PalProxy;
	outClActHeader->pImageProxy = mv_res->ImageProxy;
	// セルデータバンク
	outClActHeader->pCellBank = mv_res->CellBank;
	// セルアニメデータバンク
	outClActHeader->pAnimBank = mv_res->AnmBank;
	// マルチセルデータバンク
	outClActHeader->pMCBank = NULL;
	// マルチセルアニメデータバンク
	outClActHeader->pMCABank = NULL;
	// 転送フラグ
	outClActHeader->flag = 0;
	// BG表示優先順位
	outClActHeader->priority = inPriority;

	{
		outAdd->ClActSet	= wk->ClactSet;
		outAdd->ClActHeader	= outClActHeader;

		outAdd->mat.x		= 0;
		outAdd->mat.y		= 0;
		outAdd->mat.z		= 0;
		outAdd->sca.x		= FX32_ONE;
		outAdd->sca.y		= FX32_ONE;
		outAdd->sca.z		= FX32_ONE;
		outAdd->rot			= 0;
		outAdd->pri			= 0;
		outAdd->DrawArea	= inVramType;
		outAdd->heap		= HEAPID_ENDING_DEMO;
	}
}

//------------------------------------------------------------------
/**
 * Ｖタスク登録
 *
 * @param   wk			ワークポインタ
 *
 * @retval  none
 */
//------------------------------------------------------------------
static void SetVTask(GS_ENDING_DEMO_WORK *wk)
{
	STAFF_ROLL *sr;
	sr = &wk->StaffRoll;
	sr->Slide.Tcb = VIntrTCB_Add( TCB_Slide, &sr->Slide, 0 );
	wk->DispSwitch.Tcb = VIntrTCB_Add( TCB_DispSwitch, &wk->DispSwitch, 1 );
}

//------------------------------------------------------------------
/**
 * Ｖタスク削除
 *
 * @param   wk			ワークポインタ
 *
 * @retval  none
 */
//------------------------------------------------------------------
static void DelVTask(GS_ENDING_DEMO_WORK *wk)
{
	STAFF_ROLL *sr;
	sr = &wk->StaffRoll;
	TCB_Delete(sr->Slide.Tcb);
	sr->Slide.Tcb = NULL;
	TCB_Delete(wk->DispSwitch.Tcb);
	wk->DispSwitch.Tcb = NULL;
}

//------------------------------------------------------------------
/**
 * スタッフロールメイン
 *
 * @param   wk			ワークポインタ
 *
 * @retval  none
 */
//------------------------------------------------------------------
static void StaffRollMain(GS_ENDING_DEMO_WORK *wk)
{
	SLIDE_TYPE type;
	u8 chg_req;
	SLIDE_WORK *slide;
	STAFF_ROLL *sr;
	sr = &wk->StaffRoll;
	slide = &sr->Slide;

	chg_req = 0;

	if ( sr->PageNum >= PAGE_MAX){
		return;
	}
#if 0
	if(sys.trg & PAD_BUTTON_A){
		chg_req = 1;
	}
#endif

	//ページ表示タイミングか？
	if (wk->TotalFrame == PgDat[sr->PageNum].StartFrm){
		chg_req = 1;
	}
	switch(sr->Seq){
	case SR_SEQ_DISP_WAIT:
		sr->Counter++;
		if ( sr->Counter >= PgDat[sr->PageNum].DispWait ){
			ReqSlide(slide, wk->bgl, SLIDE_TYPE_OUT);
			sr->Seq = SR_SEQ_SLIDE_OUT_WAIT;
		}
		break;
	case SR_SEQ_SLIDE_IN_START:
		//スライドインするタイミングか？
		if ( chg_req ){
			//スライドインをリクエスト
			ReqSlide(slide, wk->bgl, SLIDE_TYPE_IN);
			sr->Seq = SR_SEQ_SLIDE_IN_WAIT;
		}
		break;
	case SR_SEQ_SLIDE_IN_WAIT:
		//スライドイン待ち
		if ( !CheckSlide(slide) ){
			sr->Counter = 0;
			//表示シーケンスへ
			sr->Seq = SR_SEQ_DISP_WAIT;
		}
		break;
	case SR_SEQ_SLIDE_OUT_WAIT:
		//スライドアウト待ち
		if ( !CheckSlide(slide) ){
			//次のページがある場合はＢＭＰに書いておく
			RewritePage(sr);
			//ページ数をインクリメント
			sr->PageNum++;
			//スライドインスタートシーケンスへ
			sr->Seq = SR_SEQ_SLIDE_IN_START;
		}
		break;
	}
}

//------------------------------------------------------------------
/**
 * ポケダンスメイン
 *
 * @param   wk			ワークポインタ
 *
 * @retval  none
 */
//------------------------------------------------------------------
static void PokeDanceMain(GS_ENDING_DEMO_WORK *wk)
{
	u8 i;
	u8 chg_req;
	POKE_DANCE *dance;
	dance = &wk->PokeDance;

	chg_req = 0;

	if (dance->ChgCount>=BGFRM_MAX){
		return ;
	}

#if 0
	if (sys.trg & PAD_BUTTON_SELECT){
		chg_req = 1;
	}
#endif

	//変更タイミングかをチェック
	if (wk->TotalFrame == BgFrmDat[dance->ChgCount]){
		chg_req = 1;
	}

	if (chg_req){
		if ( dance->Seq == DC_SEQ_NONE ){
			dance->Seq = DC_SEQ_START;
		}
	}

	switch(dance->Seq){
	case DC_SEQ_NONE:
		break;
	case DC_SEQ_START:
		//煙アニメスタート
		for (i=0;i<DANCE_POKE_NUM;i++){
			CLACT_SetDrawFlag(dance->Smog[i], 1);	//表示
			CLACT_AnmChg( dance->Smog[i], PD_ANM_SMG );
		}
		dance->Counter = 0;
		dance->Seq = DC_SEQ_POKE_CHG;
		break;
	case DC_SEQ_POKE_CHG:
		dance->Counter++;
		if (dance->Counter >= CONT_POKE_CHANGE){
			u8 scene;
			//シーンをインクリメント
			dance->Scene = (dance->Scene+1)%DANCE_SC_NUM;
			scene = dance->Scene;
			//ポケの変更(セルアニメナンバー変更)
			for (i=0;i<DANCE_POKE_NUM;i++){
				CLACT_AnmChg( dance->Poke[i], SceneDancePoke[scene] );
			}
			//ＢＧ転送開始
			{
				GF_BGL_ScreenBufSet( wk->bgl, GF_BGL_FRAME3_S,
					wk->Scrn2Data[scene]->rawData, wk->Scrn2Data[scene]->szByte );
				GF_BGL_LoadScreenV_Req(wk->bgl, GF_BGL_FRAME3_S);
				GF_BGL_ScreenBufSet( wk->bgl, GF_BGL_FRAME2_S,
					wk->Scrn1Data[scene]->rawData, wk->Scrn1Data[scene]->szByte );
				GF_BGL_LoadScreenV_Req(wk->bgl, GF_BGL_FRAME2_S);
				GF_BGL_ScreenBufSet( wk->bgl, GF_BGL_FRAME3_M,
					wk->Scrn2Data[scene]->rawData, wk->Scrn2Data[scene]->szByte );
				GF_BGL_LoadScreenV_Req(wk->bgl, GF_BGL_FRAME3_M);
				GF_BGL_ScreenBufSet( wk->bgl, GF_BGL_FRAME2_M,
					wk->Scrn1Data[scene]->rawData, wk->Scrn1Data[scene]->szByte );
				GF_BGL_LoadScreenV_Req(wk->bgl, GF_BGL_FRAME2_M);
			}
			dance->Counter = 0;
			dance->Seq = DC_SEQ_CHG_WAIT;
		}
		break;
	case DC_SEQ_CHG_WAIT:
		dance->Counter++;
		if (dance->Counter >= WAIT_POKE_CHANGE){
			//煙消す
			for (i=0;i<DANCE_POKE_NUM;i++){
				CLACT_SetDrawFlag(dance->Smog[i], 0);	//非表示
			}
			dance->Counter = 0;
			dance->Seq = DC_SEQ_NONE;
			//変更回数インクリメント
			dance->ChgCount++;
		}
	}
}

//------------------------------------------------------------------
/**
 * 画面切り替えメイン
 *
 * @param   wk			ワークポインタ
 *
 * @retval  none
 */
//------------------------------------------------------------------
static void DispSwitchMain(GS_ENDING_DEMO_WORK *wk)
{
	u8 chg_req;
	DISP_SWITCH *sw;

	sw = &wk->DispSwitch;
	chg_req = 0;

	if (sw->SwNum >= SWITCH_MAX){
		return;
	}
#if 0
	if (sys.trg & PAD_BUTTON_X){
		//切り替えリクエスト
		chg_req = 1;
	}
#endif

	//切り替えタイミングか？
	if ( wk->TotalFrame == SwDat[sw->SwNum] ){
		chg_req = 1;
	}

	if (chg_req){
		ReqDispSwitch(wk);
	}
}

//------------------------------------------------------------------
/**
 * フィールドアクター動作メイン
 *
 * @param   wk			ワークポインタ
 *
 * @retval  none
 */
//------------------------------------------------------------------
static void ActMovMain(GS_ENDING_DEMO_WORK *wk)
{
	MOV_ACT *mov;
	mov = &wk->MovActMng.MovAct;

	if (wk->MovActMng.SceneNo >= SCENE_DAT_MAX){
		return;
	}

	//現在シーンの監視
	{
		u8 i;
		u8 stop_num = 0;
		for (i=0;i<mov->EntryIdx;i++){
			ACTOR *actor = &mov->Actor[i];
			//出演タイミング？
			if ( wk->TotalFrame == actor->StartFrm){
				//アクター動作開始
				StartActMov(actor->ActPtr);
			}

			if ( !CLACT_AnmActiveCheck(actor->ActPtr) ){
				stop_num++;
			}
		}

		//出演者のアニメがすべて終了したか？
		if (stop_num == mov->EntryIdx){
			OS_Printf("シーン%d終了：：トータルフレーム%d\n",
					wk->MovActMng.SceneNo, wk->TotalFrame);
			FreeScene(wk);
			//次のシーン
			wk->MovActMng.SceneNo++;
			SetupNextScene( wk );
		}
	}

}

//------------------------------------------------------------------
/**
 * アクター動作開始
 *
 * @param   act		アクターワークポインタ
 *
 * @retval  none
 */
//------------------------------------------------------------------
static void StartActMov(CLACT_WORK_PTR act)
{
	CLACT_SetAnmFlag(act, 1);	//アニメ
	CLACT_SetDrawFlag(act, 1);	//表示
}

//------------------------------------------------------------------
/**
 * 画面切り替えリクエスト
 *
 * @param   wk			ワークポインタ
 *
 * @retval  none
 */
//------------------------------------------------------------------
static void ReqDispSwitch(GS_ENDING_DEMO_WORK *wk)
{
	DISP_SWITCH *dsp_sw;

	dsp_sw = &wk->DispSwitch;
	dsp_sw->Req = 1;
	//切り替え回数インクリメント
	dsp_sw->SwNum++;
}

//------------------------------------------------------------------
/**
 * 画面切り替えＴＣＢ
 *
 * @param   tcb		タスクポインタ
 * @param	work	ワークポインタ
 *
 * @retval  none
 */
//------------------------------------------------------------------
static void TCB_DispSwitch( TCB_PTR tcb, void* work )
{
	DISP_SWITCH *dsp_sw;
	dsp_sw = work;

	if (dsp_sw->Req){
		dsp_sw->Req = 0;
		//切り替え
		if (sys.disp3DSW == DISP_3D_TO_SUB){
			sys.disp3DSW = DISP_3D_TO_MAIN;
		}else{
			sys.disp3DSW = DISP_3D_TO_SUB;
		}
		GF_Disp_DispSelect();
	}
}

//------------------------------------------------------------------
/**
 * BMPウィンドウ作成
 *
 * @param   wk			ワークポインタ
 *
 * @retval  none
 */
//------------------------------------------------------------------
static void CreateBmpWin(GS_ENDING_DEMO_WORK *wk)
{
	STAFF_ROLL *sr;
	const BMPWIN_DAT * dat = &BmpData;

	sr = &wk->StaffRoll;

	GF_BGL_BmpWinAddEx( wk->bgl, &sr->Win, dat );

	//先頭キャラをクリア（スクリーンクリアされてるところは、このキャラで埋まる）
	GF_BGL_CharFill( wk->bgl, MSG_BG, 0, 1, 0 );

	//システム用フォントパレット転送
	SystemFontPaletteLoad(PALTYPE_SUB_BG, FONT_PAL*32, HEAPID_ENDING_DEMO);

	GF_Disp_GXS_VisibleControl( GX_PLANEMASK_BG1, VISIBLE_ON );
}

//------------------------------------------------------------------
/**
 * スライドリクエスト
 *
 * @param   work			ワークポインタ
 * @param	bgl				BGL
 * @param	inType			スライドタイプ
 *
 * @retval  none
 */
//------------------------------------------------------------------
static void ReqSlide(SLIDE_WORK *work, GF_BGL_INI *bgl, const SLIDE_TYPE inType)
{
	GF_ASSERT_MSG(work->Valid == FALSE, "文字スライド中\n");
	{
		int in_mask = GX_WND_PLANEMASK_BG1|GX_WND_PLANEMASK_BG2|GX_WND_PLANEMASK_BG3|GX_WND_PLANEMASK_OBJ;
		int out_mask = GX_WND_PLANEMASK_BG2|GX_WND_PLANEMASK_BG3|GX_WND_PLANEMASK_OBJ;
		GXS_SetVisibleWnd( GX_WNDMASK_W0|GX_WNDMASK_W1 );
		G2S_SetWnd0InsidePlane( in_mask, 1 );
		G2S_SetWnd1InsidePlane( in_mask, 1 );
		G2S_SetWndOutsidePlane( out_mask, 1 );
	}
	work->Counter = 0;
	work->Valid = TRUE;
	work->Type = inType;
	work->Bgl = bgl;

	//ＢＧ出す
	GF_Disp_GXS_VisibleControl( GX_PLANEMASK_BG1, VISIBLE_ON );
}

//------------------------------------------------------------------
/**
 * スライド中チェック
 *
 * @param   work			ワークポインタ
 *
 * @retval  BOOL			TRUEで稼働中
 */
//------------------------------------------------------------------
static BOOL CheckSlide(SLIDE_WORK *work)
{
	return work->Valid;
}

//------------------------------------------------------------------
/**
 * スライドＴＣＢ
 *
 * @param	tcb				タスクポインタ
 * @param   work			ワークポインタ
 *
 * @retval  none
 */
//------------------------------------------------------------------
static void TCB_Slide( TCB_PTR tcb, void* work )
{
	int sx,ex;
	int x;
	SLIDE_WORK *wk = work;

	//リクエストがない場合は処理しない
	if (!wk->Valid){
		return;
	}

	wk->Counter++;

	if (wk->Type == SLIDE_TYPE_IN ){
		sx = 255 - ( (255*wk->Counter) / SLIDE_SYNC );
		ex = 255;
	}else{
		sx = 0;
		ex = 255 - ( (255*wk->Counter) / SLIDE_SYNC );
	}

	x = (255 * wk->Counter) / SLIDE_SYNC;

	if (wk->Counter >= SLIDE_SYNC){
		wk->Valid = FALSE;
		if (wk->Type == SLIDE_TYPE_IN){
			//ＢＧ出す
			GF_Disp_GXS_VisibleControl( GX_PLANEMASK_BG1, VISIBLE_ON );
		}else{
			//ＢＧ消す
			GF_Disp_GXS_VisibleControl( GX_PLANEMASK_BG1, VISIBLE_OFF );
		}
	}

	SetWinRect(sx, 0, ex, 192);
	GF_BGL_ScrollSet( wk->Bgl, MSG_BG, GF_BGL_SCROLL_X_SET, x );
}

//------------------------------------------------------------------
/**
 * ウィンドウマスク矩形作成
 *
 * @param   inSX		開始Ｘ
 * @param	inSY		開始Ｙ
 * @param	inEX		終了Ｘ
 * @param	inEY		終了Ｙ
 *
 * @retval  none
 */
//------------------------------------------------------------------
static void SetWinRect(const int inSX, const int inSY, const int inEX, const int inEY)
{
	if ((inSX == 0)&&(inEX == 255)){
		int wnd1_sx = 0;
		int wnd1_ex = 1;
		int wnd0_sx = 1;
		int wnd0_ex = 0;

		G2S_SetWnd1Position( wnd1_sx, inSY, wnd1_ex, inEY );
		G2S_SetWnd0Position( wnd0_sx, inSY, wnd0_ex, inEY );
	}else{
		G2S_SetWnd0Position( inSX, inSY, inEX, inEY );
	}
}

//------------------------------------------------------------------
/**
 * ページのリライト
 *
 * @param   sr			スタッフロール管理ポインタ
 *
 * @retval  none
 */
//------------------------------------------------------------------
static void RewritePage(STAFF_ROLL* sr)
{
	u16 next_page, write_page;

	//今回書くページ番号
	write_page = sr->PageNum+1;
	//範囲外チェック
	if (write_page >= PAGE_MAX){
		return;	//もう書くページなし
	}

	next_page = StfDat[sr->StfDatIdx].PageNo;

	//クリーン
	GF_BGL_BmpWinDataFill( &sr->Win, 0);

	while(next_page==write_page){
		int msg_id;
		u8 x,y;

		msg_id = StfDat[sr->StfDatIdx].MsgID;
		x = StfDat[sr->StfDatIdx].X;
		y = StfDat[sr->StfDatIdx].Y;

		MSGMAN_GetString( sr->MsgMan, msg_id, sr->StrBuf );
		GF_STR_PrintColor( &sr->Win, FONT_SYSTEM, sr->StrBuf, x, y,
						MSG_NO_PUT, GF_PRINTCOLOR_MAKE(1,2,0), NULL );
		sr->StfDatIdx++;

		if (sr->StfDatIdx >= STF_DAT_MAX){
			break;
		}

		next_page = StfDat[sr->StfDatIdx].PageNo;
	}

	GF_BGL_BmpWinOn(&sr->Win);
}

//////////////////////////////////////////////////////////////////////

//----------------------------------------------------------------------------
/**
 *	@brief	ＶＲＡＭアドレス割り当て
 *
 *	@param	wk			ワークポインタ
 *
 *	@return	none
 */
//-----------------------------------------------------------------------------
static void AttouchVramAdr( GS_ENDING_DEMO_WORK *wk )
{
	CLACT_U_RES_OBJ_PTR res_obj_ptr;
	CLACT_U_RES_OBJ_PTR res_pal_ptr;
	NNSG2dImageProxy *image_proxy;
	const NNSG2dImagePaletteProxy *palette_proxy;
	MOV_ACT_MNG *mng;

	u8 i;
	mng = &wk->MovActMng;

	for(i=0;i<FLDMOV_MAX;i++){
		res_obj_ptr = wk->FldResObjTbl[i][CLACT_U_CHAR_RES];
		res_pal_ptr = wk->FldResObjTbl[i][CLACT_U_PLTT_RES];
		image_proxy = CLACT_U_CharManagerGetProxy( res_obj_ptr );
		palette_proxy = CLACT_U_PlttManagerGetProxy( res_pal_ptr, image_proxy );

		OS_Printf("img=%x\n",image_proxy);
		OS_Printf("pal=%x\n",palette_proxy);


		mng->MvRes[i].ImageProxy = image_proxy;
		mng->MvRes[i].PalProxy = palette_proxy;
		mng->MvRes[i].ImageVram = NNS_G2dGetImageLocation( image_proxy, NNS_G2D_VRAM_TYPE_2DMAIN );
		mng->MvRes[i].PaletteVram = NNS_G2dGetImagePaletteLocation( palette_proxy, NNS_G2D_VRAM_TYPE_2DMAIN );
		OS_Printf("img_v=%x\n",mng->MvRes[i].ImageVram);
		OS_Printf("pal_v=%x\n",mng->MvRes[i].PaletteVram);
	}
}

//----------------------------------------------------------------------------
/**
 *	@brief	使用する人物のリソースをロード
 *
 *	@param	mng		マネージャポインタ
 *	@param	inResNo	リソース番号		scene.dat参照
 *
 *	@return none
 */
//-----------------------------------------------------------------------------
static void LoadSceneRes(MOV_ACT_MNG *mng, const u8 inResNo)
{
	const heapid = HEAPID_ENDING_DEMO;

	void *chr_data;
	void *pal_data;
	NNSG2dCharacterData *charData;
	NNSG2dPaletteData  *palData;
	u8 res_no;
	u8 player_res, support_res;

	u8 is_player = 0;
	u8 is_support = 0;

	res_no = inResNo;

	OS_Printf("読み込むリソース番号%d\n",res_no);

	//読み込もうとしているリソースが主人公ＯＲサポーターならば性別で分岐
	if (res_no == RES_PLAYER){
		is_player = 1;
		if (mng->PlayerSex == PM_FEMALE){		//女の子主人公
			player_res = RES_SUPPORT;
		}else{									//男の子主人公
			player_res = RES_PLAYER;
		}
	}else if (res_no == RES_SUPPORT){
		is_support = 1;
		if (mng->PlayerSex == PM_FEMALE){		//女の子主人公
			support_res = RES_PLAYER;
		}else{									//男の子主人公
			support_res = RES_SUPPORT;
		}
	}

	if (is_player){			//主人公キャラ・パレット
		//--chara読み込み
		chr_data = ArcUtil_HDL_CharDataGet( mng->Handle, GraDatTbl[player_res].cgr, TRUE, &charData, heapid );
		//--pal読み込み
		pal_data = ArcUtil_HDL_PalDataGet( mng->Handle, GraDatTbl[player_res].clr, &palData, heapid );
	}else if(is_support){		//サポートキャラ・パレット
		//--chara読み込み
		chr_data = ArcUtil_HDL_CharDataGet( mng->Handle, GraDatTbl[support_res].cgr, TRUE, &charData, heapid );
		//--pal読み込み
		pal_data = ArcUtil_HDL_PalDataGet( mng->Handle, GraDatTbl[support_res].clr, &palData, heapid );
	}else{				//それ以外
		//--chara読み込み
		chr_data = ArcUtil_HDL_CharDataGet( mng->Handle, GraDatTbl[res_no].cgr, TRUE, &charData, heapid );
		//--pal読み込み
		pal_data = ArcUtil_HDL_PalDataGet( mng->Handle, GraDatTbl[res_no].clr, &palData, heapid );
	}

	DC_FlushRange(charData->pRawData, charData->szByte);
	GX_LoadOBJ( charData->pRawData, mng->MvRes[mng->EntryIdx].ImageVram, charData->szByte );

	DC_FlushRange( palData->pRawData, palData->szByte );
	GX_LoadOBJPltt( palData->pRawData, mng->MvRes[mng->EntryIdx].PaletteVram, ACT_PAL_SIZE );

	//--cell読み込み
	mng->MvRes[mng->EntryIdx].CellData = ArcUtil_HDL_CellBankDataGet(mng->Handle, GraDatTbl[res_no].cer,
														TRUE, &mng->MvRes[mng->EntryIdx].CellBank, heapid);
	//--anim読み込み
	mng->MvRes[mng->EntryIdx].AnmData = ArcUtil_HDL_AnimBankDataGet(mng->Handle, GraDatTbl[res_no].anr,
														TRUE, &mng->MvRes[mng->EntryIdx].AnmBank, heapid);

	OS_Printf("%d:転送ＶＲＡＭ位置＝%x\n",mng->EntryIdx, mng->MvRes[mng->EntryIdx].ImageVram);
	OS_Printf("%d:転送palＶＲＡＭ位置＝%x\n",mng->EntryIdx, mng->MvRes[mng->EntryIdx].PaletteVram);

	sys_FreeMemoryEz(chr_data);
	sys_FreeMemoryEz(pal_data);

	//エントリーインデックスをインクリメント
	mng->EntryIdx++;
}

//----------------------------------------------------------------------------
/**
 *	@brief	シーンアクターセット
 *
 *	@param	wk		ワークポインタ
 *	@param	sc_act	シーン役者データポインタ
 *
 *	@return none
 */
//-----------------------------------------------------------------------------
static void SetSceneActor( GS_ENDING_DEMO_WORK *wk, const SC_ACT *sc_act )
{
	CLACT_HEADER	cl_act_header;
	CLACT_ADD add;
	MOV_ACT *mov;
	ACTOR *actor;

	OS_Printf("ヘッダー作成読み込みリソース番号%d\n",sc_act->ResIdx);
	//ヘッダー作成
	MakeClActHeaderForFldMov(	sc_act->ResIdx, wk, FLD_MOV_BG_PRI,
								NNS_G2D_VRAM_TYPE_2DMAIN,
								&add, &cl_act_header);
	mov = &wk->MovActMng.MovAct;

	//未使用アクターを取得
	actor = &mov->Actor[mov->EntryIdx];
	actor->Valid = 1;
	actor->Code = sc_act->ActCode;

	{

		add.mat.x = FX32_ONE * sc_act->X;
		add.mat.y = FX32_ONE * (DIFF_MAIN_SUB_LCD+sc_act->Y);
		add.pri = 1;

		actor->ActPtr = CLACT_Add(&add);
		GF_ASSERT(actor->ActPtr != NULL );
		CLACT_SetAnmFlag(actor->ActPtr,0);	//アニメ止めておく
		CLACT_SetDrawFlag(actor->ActPtr, 0);	//非表示
		CLACT_AnmChg( actor->ActPtr, sc_act->AnmNo );
		actor->StartFrm = sc_act->Frm;		//開始フレームセット
	}
	//エントリーインデックスをインクリメント
	mov->EntryIdx++;
}

//----------------------------------------------------------------------------
/**
 *	@brief	今回のシーンで使うリソースと出演者のセットアップ
 *
 *	@param	wk		ワークポインタ
 *
 *	@return none
 */
//-----------------------------------------------------------------------------
static void SetupNextScene( GS_ENDING_DEMO_WORK *wk )
{
	//リソースのセットアップ
	u8 i;
	u8 scene_no;
	MOV_ACT_MNG *mng;
	const SCENE_DAT *sc_dat;
	u32 first_frm;

	mng = &wk->MovActMng;

	scene_no = mng->SceneNo;

	if (scene_no >= SCENE_DAT_MAX){
		return;	//全シーン終了
	}

	sc_dat = &SceneDat[scene_no];

	GF_ASSERT(sc_dat->ResNum <= FLDMOV_MAX);

	//シーンデータリソース分ループ
	for (i=0;i<sc_dat->ResNum;i++){
		LoadSceneRes(mng, sc_dat->ResNo[i]);
	}

	first_frm = 0xffffffff;

	GF_ASSERT(sc_dat->ActNum <= MOV_ACTOR_MAX);

	//登場者のセットアップ
	for (i=0;i<sc_dat->ActNum;i++){
		SetSceneActor( wk, &sc_dat->ScAct[i] );
		//シーン内で初めて登場する役者のフレーム数を調べる
		if (first_frm > sc_dat->ScAct[i].Frm){
			first_frm = sc_dat->ScAct[i].Frm;
		}
	}

	OS_Printf("シーン%dの開始フレーム%d\n",scene_no, first_frm);

	GF_ASSERT_MSG( (first_frm > wk->TotalFrame),"シーン開始フレームが既に過ぎている\n" );
}

//----------------------------------------------------------------------------
/**
 *	@brief	アニメシーンが終わったときの次のシーン読み込みの前に行う解放処理
 *
 *	@param	wk		ワークポインタ
 *
 *	@return none
 */
//-----------------------------------------------------------------------------
static void FreeScene(GS_ENDING_DEMO_WORK *wk)
{
	MOV_ACT_MNG *mng = &wk->MovActMng;
	MOV_ACT *mov = &mng->MovAct;
	ACTOR *actor = mov->Actor;
	u8 i;
	//使用していたセルアクターを削除
	for (i=0;i<MOV_ACTOR_MAX;i++){
		if(actor[i].Valid){
			//セルアクター削除
			CLACT_Delete(actor[i].ActPtr);
			//有効フラグ落とす
			actor[i].Valid = 0;
			//出演者コードクリア
			actor[i].Code = 0;
		}
	}
	//エントリインデックスをクリア
	mov->EntryIdx = 0;

	//エントリーした分のセルデータとセルアニメデータを削除
	for (i=0;i<mng->EntryIdx;i++){
		sys_FreeMemoryEz(mng->MvRes[i].CellData);
		sys_FreeMemoryEz(mng->MvRes[i].AnmData);
		mng->MvRes[i].CellBank = NULL;
		mng->MvRes[i].AnmBank = NULL;
	}
	//エントリインデックスをクリア
	mng->EntryIdx = 0;
}